This PR implements configurable memory limits for shell executor jobs, completing the resource management capabilities that were partially introduced in PR #758.

Problem

While analyzing PR #758, I discovered that Dkron already has comprehensive timeout functionality and Prometheus metrics, but was missing the memory limit enforcement feature. This left a gap in resource management where jobs could consume excessive memory without any built-in protection mechanism.

Solution

Added a new mem_limit parameter to the shell executor that provides:

• Flexible memory unit support: Accepts values like "512MB", "1GB", "1024" (bytes), "1.5GB", etc.
• Real-time monitoring: Checks memory usage every second during job execution
• Process tree awareness: Monitors memory consumption of both parent and child processes
• Automatic termination: Kills jobs when memory limit is exceeded with clear logging
• Robust validation: Comprehensive input validation with detailed error messages

Implementation Details

Job Validation (dkron/job.go)

if j.Executor == "shell" && j.ExecutorConfig["mem_limit"] != "" {
    err := validateMemoryLimit(j.ExecutorConfig["mem_limit"])
    if err != nil {
        return fmt.Errorf("Error parsing job memory limit value: %v", err)
    }
}

Shell Executor Enhancement (plugin/shell/shell.go)

The implementation integrates seamlessly with existing process monitoring:

// Parse memory limit if specified
memLimit, err := parseMemoryLimit(args.Config["mem_limit"])
if err != nil {
    return nil, fmt.Errorf("shell: Error parsing job memory limit: %v", err)
}

// Start memory monitoring goroutine if limit is set
if memLimit > 0 {
    go func() {
        // Monitor memory usage every second and kill if exceeded
    }()
}

Documentation Updates

Added comprehensive documentation including:

• Parameter reference table with mem_limit description
• Usage examples for memory limits and combined timeout/memory scenarios
• Troubleshooting guidance for memory-related issues

Usage Examples

Basic memory limit:

{
  "executor": "shell",
  "executor_config": {
    "command": "/opt/scripts/data_processing.sh",
    "mem_limit": "512MB"
  }
}

Combined resource limits:

{
  "executor": "shell",
  "executor_config": {
    "command": "/opt/scripts/intensive_task.sh", 
    "timeout": "30m",
    "mem_limit": "1GB"
  }
}

Testing

• ✅ Comprehensive unit tests for memory limit parsing and validation
• ✅ Integration tests covering various memory unit formats
• ✅ Edge case testing (invalid formats, negative values, overflow protection)
• ✅ Backward compatibility verified - all existing tests pass
• ✅ End-to-end validation of job creation and execution flow

Benefits

1. Enhanced Resource Protection: Prevents runaway jobs from consuming excessive memory
2. Operational Safety: Complements existing timeout functionality for complete resource management
3. Monitoring Integration: Works seamlessly with existing Prometheus metrics collection
4. User-Friendly Configuration: Simple parameter with flexible unit support
5. Production Ready: Robust validation, error handling, and comprehensive logging

This implementation completes the resource management story for Dkron shell jobs, providing administrators with both time-based (timeout) and memory-based (mem_limit) controls to ensure reliable job execution within defined resource boundaries.

💬 Share your feedback on Copilot coding agent for the chance to win a $200 gift card! Click here to start the survey.